;;; 
var Y = (function(){
/* 如果是个位数，数字会多个0.例   9=09
*bw(time)  补零
*@params   time  {string|number}  需要补位的数
*/
function bw (time) {
    return time > 9 ? time : "0" + time
}


/* 
*sum(a,b)   求 两个数之间的和（包含两个数）
*@params  min   {number}  小值
*@params  max   {number}  大值
*/
function sum (min, max) {
    var sum1 = 0;//存和
    for (var i = min; i <= max; i++) {
        sum1 += i
    }
    //返回值 和
    return sum1
}


/* 获取元素属性，例，div的高度
*getStyle(el,attr)   获取样式
*@params  el   {object}  元素
*@params  attr {string}  样式名
*/
//标准的============-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=
// console.log(window.getComputedStyle(odiv).width);
//IE的=============-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-==-=-=
// console.log(odiv.currentStyle.width);
function getStyle (el, attr) {
    //判断有没有 window.getComputedStyle 有没有这个方法
    if (window.getComputedStyle) {
        return getComputedStyle(el)[attr]
    } else {
        return el.currentStyle[attr]
    }
}


/* 轮播图类型
*move (el, attr, step, target)  运动函数
*@params  el   {object}  元素
*@params  attr {string}  样式名
*@params  step {number}  步长  通常使用 10
*@params  target {number}  目标值
*/
 // el（运动的元素odiv）attr（运动的属性left）step（每次一定的距离）target（终点）
function move (el, attr, step, target) {
    // 先判断出step是正值还是负值    
    // target 目标值 > 初始值  step 正值 
    // target 目标值 < 初始值  step 负值值 
    //初始值
    var current = parseInt(getStyle(el, attr))
    step = target > current ? step : -step
    // 在频繁触发定时器时先清除定时器
    clearInterval(el.timer) //取el身上的自定义属性
    el.timer = setInterval(function () { //在el身上设置自定义属性 值 就是定时器id
        // 3、获取当前div的left值
        var speed = parseInt(getStyle(el, attr)) + step
        //    判断条件不一样
        //  target  0   500 speed  向左 speed<=target    step<0
        //  target  500   0 speed  向右 speed >= target   step>0
        if ((speed <= target && step < 0) || (speed >= target && step > 0)) {
            speed = target
            clearInterval(el.timer)
        }
        // 4、设置div 的left值
        el.style[attr] = speed + 'px'
    }, 30);
}
/* 
*getRandom (max, min)  获取随机整数
*@params  max   {number}  最大值
*@params  min   {number}  最小值
*/
//封装一个随机整数
function getRandom (max, min) {
    return Math.floor((Math.random() * ((max - min) + 1)) + min)
}

/* 
*verCode(n)  获取n位验证码
*@params  n   {number}  n位验证码  
*/
function verCode(n){
    var str ="1234567890qwertyuiopasdfghjklzxcvbnmQWERTYUIOPLKJHGFDSAZXCVBNM"
    console.log(str.length); //62
       var  s = '' //存储验证码  
       for(var i=0;i<n;i++){
            s+=str[getRandom(str.length-1,0)]
       }
      return s
}


/* 
* filterWorld(str,world)  替换过滤次
*@params str   {string}     需要过滤的字符串
*@params world   {string}   过滤次  
*/
function filterWorld(str,world){
    //确定第一次是否能找到,也同时确认了循环次数
    var n = str.indexOf(world) //找到返回是一个下标 找不到返回 -1 
    // n =6
    while(n != -1){
        //循环一次，更新一次下标值（n）
        str = str.replace(world,'**')
        // 更新循环
        n = str.indexOf(world) //n = 9   n = 16  n=-1
    }
// console.log(str); //"刘德华爱上了**，**高兴坏了，**高兴坏了"
   return str

}


/* 
* pswStrength(str)  验证密码强度
*@params  str   {string} 字符串    需要验证的密码 
*/
function pswStrength(str){
    if(re.test(str)){
        return '弱'
    }else if(re1.test(str)){
        return '中'
    }else if(re2.test(str)){
        return '强'
    }else {
        return '密码必须是数字字母组合！'
    }
}

/* 
* Attr(el,attr,v) 获取和设置属性
*@params  el   {object}     元素   odiv
*@params  attr {string}    属性名   随意名字/id/class/asd
*@params  v    {string||boolean}     任何类型  更随便
          例子：   Attr(oli[i],'index',i)
*/
function Attr(el,attr,v){
    //判断是设置还是获取
    if(v==undefined){//获取
        return el.getAttribute(attr)
    }else{//设置
       el.setAttribute(attr,v)
    }
}


/* 
* insertAfter(liEl,threeLi)  在某个元素之后插入元素节点
*@params  liEl   {object}     要插入的元素节点
*@params  threeLi {object}    参考节点
*/
function insertAfter(liEl,threeLi){
    // 1、找出父级
   var parent = threeLi.parentNode
    // 2、找出参考节点的下一个元素
    // 1、找不到 直接在ul末尾添加 appendChild      #text
    // 2、找到直接使用insertBefore       class为four     
    var nextEl = threeLi.nextElementSibling || threeLi.nextSibling
    // console.log(nextEl.nodeType);
    if(nextEl.nodeType==1){
        oul.insertBefore(liEl,nextEl)
    }else{
        oul.appendChild(liEl)
    }
}

/* 添加额外的class名字
* addClass(el,v)  添加class
*@params  el   {object}    元素
*@params  v {object}    class值
*/
function  addClass(el,v){
    //判断有没有class值
    if(el.className){
        // 有class  判断已经存在需要添加的class
        var arr = el.className.split(" ") // ["box", "aa", "bb"]
        if(arr.indexOf(v)==-1){
            arr.push(v)
          el.className = arr.join(" ")
        }
    }else{
        // 直接添加
        el.className = v
    }
}
/* 删除一个class名
* removeClass(el,v)  删除class
*@params  el   {object}    元素
*@params  v {object}    class值
*/

function  removeClass(el,v){
    // 判断有没有class
    if(el.className){
        // 有没有要删除的class
       var arr =  el.className.split(" ")
       if(arr.indexOf(v)!=-1){
            arr.splice(arr.indexOf(v),1)
            el.className = arr.join(" ")
       }
    }
}

/* 
*bind(el,type,EventFn)  相同元素事件绑定
*@params  el   {object}    元素
*@params  type {string}    事件类型 （不加on）/click
*@params  EventFn {Function}  事件函数（函数名）
*@params  引用函数后，直接function fn(){}
*/
function bind (el, type, EventFn) {
    // 兼容
    if (el.addEventListener) { //标准
        el.addEventListener(type, EventFn, false)
    } else {
        el.attachEvent("on" + type, EventFn)
    }
}

/* 
*unbind(el,type,eventFn)  相同元素事件取消
*@params  el   {object}    元素
*@params  type {string}    事件类型 （不加on）
*@params  EventFn {Function}  事件函数
*/
function unbind (el, type, eventFn) {
    // 判断浏览器
    if (el.removeEventListener) {
        el.removeEventListener(type, eventFn, false)
    } else {
        el.detachEvent('on' + type, eventFn)
    }
}

/* 
*stopPropagation (ev)  阻止事件冒泡
*@params  ev   {object}    事件对象
*/
// 封装 兼容ie 和标准 的 阻止冒泡的函数,在事件元素函数内使用
function stopPropagation (ev) {
    // 判断什么浏览器
    if (ev.stopPropagation) {
        ev.stopPropagation()
    } else {
        ev.cancelBubble = true
    }
}

/* 阻止默认的例如，右键出现的菜单列表,在事件元素函数内使用
*preventDefault (ev)     阻止默认行为(一般来说就是ev)
*@params  ev   {object}    事件对象
*/
function preventDefault(ev){
    // 判断是什么浏览器
    if(ev.preventDefault){
        ev.preventDefault()
    }else{
        ev.returnValue =false
    }
}

/* 轮播图   4月28日     BannerMove(oul,'left',-n*imgW)     轮播图（缓冲）！！
*BannerMove(el, attr, target)  缓冲运动         用于：方向、大小
*@params  el   {object}   运动的元素
*@params  attr   {string}    运动的属性
*@params  target   {number}    目标值
*/     
function BannerMove(el, attr, target) {
    // 在频繁触发定时器时 清楚定时器
    clearInterval(el.timer)
    el.timer = setInterval(function () {
        // 1、获取当前的div 的left 
        var current = parseInt(getStyle(el, attr))
        //确认速度speed，向上取整
        var speed = target>current?Math.ceil((target - current) / 10):Math.floor((target - current) / 10)
        // 2、判断方向
        if ((current >= target && speed>=0)  || (current <= target && speed<=0)) {
            clearInterval(el.timer)
            current = target
        }       
        // 3、不断赋值
        el.style[attr] = current + speed + 'px'
    }, 30)
}


/*          4月28日        opacity(odiv,'opacity',1)
*opacity (el,attr,target)  透明度缓冲运动
*@params  el   {object}   运动的元素
*@params  attr   {string}    运动的属性
*@params  target   {number}    目标值 
*/
function opacity (el,attr,target){
    // 频繁触发定时器之前清楚定时器
    clearInterval(el.timer)
    el.timer = setInterval(function(){
        // 1、获取当前的opacity值
        var current = getStyle(el,attr)*100 //当前值扩大100倍   
        //2、目标值扩大100倍
        var end = target*100 
        // 如果当前透明度大于目标透明度或小于
        var speed = current>end?Math.floor((end - current) / 10):Math.ceil((end - current) / 10)
        // 达到条件后停止
        if((current>=end && speed >=0) || (current <= end && speed <=0)){
            current = end
            clearInterval(el.timer)
        }
        // 3、赋值
        el.style[attr] = (speed + current)/100 
    },30)
}

/*    可分辨透明度和px单位变量，做出选择后开始运动
  opacityBannerMove(odiv,'opacity',1,function(){
            opacityBannerMove(odiv,'height',500)
        })
opacityBannerMove(odiv,'height',500)     :例如
*opacityBannerMove(el, attr, target)  透明度和单属性缓冲运动
*@params  el   {object}   运动的元素
*@params  attr   {string}    运动的属性
*@params  target   {number}    目标值 
*@params  callback   {Function}    回调函数 
*/
function opacityBannerMove(el, attr, target,callback){
    // 频繁触发定时器之前清楚定时器
    clearInterval(el.timer)
    el.timer = setInterval(function(){
       if(attr=="opacity"){
            // 1、获取当前的opacity值
           var current = getStyle(el,attr)*100 //当前值扩大100倍   
           //2、目标值扩大100倍
           var end = target*100 
           var speed = current>end?Math.floor((end - current) / 10):Math.ceil((end - current) / 10)
             
           if((current>=end && speed >=0) || (current <= end && speed <=0)){
               current = end
               clearInterval(el.timer)

               callback && callback()
           }

            // 3、赋值
           el.style[attr] = (speed + current)/100
       }else{
           // 1、获取当前的div 的left 
           var current = parseInt(getStyle(el, attr))
           var speed = target>current?Math.ceil((target - current) / 10):Math.floor((target - current) / 10)
           // 2、判断
           if ((current >= target && speed>=0)  || (current <= target && speed<=0)) {
               clearInterval(el.timer)
               current = target
               callback && callback()
           } 
            // 3、不断赋值
           el.style[attr] = current + speed + 'px' 
       }   
   },30)
}

/* 
*bufferMove(el,json,callback) 多个属性同时缓冲运动
*@params  el   {object}   运动的元素
*@params  json   {object}   { key(运动的属性)：value(运动的目标值) }
*@params  callback   {Function}    回调函数 
*/
function bufferMove(el,json,callback){ //key  height  width  opacity     json[key]
    // 频繁触发定时器之前清楚定时器
    clearInterval(el.timer)
    el.timer = setInterval(function(){
        var flag ="都到了"
      for(var key in json){
        if(key=="opacity"){
            // 1、获取当前的opacity值
           var current = getStyle(el,key)*100 //当前值扩大100倍   
           //2、目标值扩大100倍
           var end = json[key]*100 
           var speed = current>end?Math.floor((end - current) / 10):Math.ceil((end - current) / 10)
            //改变条件为 没有到达目标点  
           if(!(current>=end && speed >=0) || !(current <= end && speed <=0)){
            flag = "没到"

           }
           console.log('111');
            // 3、赋值
           el.style[key] = (speed + current)/100
       }else{
           // 1、获取当前的div 的left 
           var current = parseInt(getStyle(el, key))
           var speed = json[key]>current?Math.ceil((json[key] - current) / 10):Math.floor((json[key] - current) / 10)
           // 2、判断
           if (!(current >= json[key] && speed>=0)  || !(current <= json[key] && speed<=0)) {
             flag = "没到"
           } 
            // 3、不断赋值
           el.style[key] = current + speed + 'px' 
       }  
      } 
      // for循环走完判断状态
      if(flag =='都到了'){
        clearInterval(el.timer)
        callback && callback()
      }
   },30)
}
  /* 
    *Storage(key,value) 本地存储  可取可存  一个参数就是获取
    *@params  key   {string}   存储的key
    *@params  value   {any}    存储的值
    */
    function Storage(key,value){
        //判断是取值还是设置
        if(value){
            //设置
            if(typeof(value)=="object"){
               localStorage[key] = JSON.stringify(value)
            }else{
                localStorage[key] = value
            }
        }else{
            // 判断是否有需要获取的值
            // console.log(localStorage.hasOwnProperty(key)); //false
            if(localStorage.hasOwnProperty(key)){
                return JSON.parse(localStorage[key])
            }else{
                return ''
            }
        }
    }


return {
    bw,
    sum,
    getStyle,
    move,
    getRandom,
    verCode,
    filterWorld,
    pswStrength,
    Attr,
    insertAfter,
    addClass,
    removeClass,
    bind,
    unbind,
    stopPropagation,
    preventDefault,
    BannerMove,
    opacity,
    opacityBannerMove,
    bufferMove,
    Storage
}
})()
